Universal container for audio data

ABSTRACT

Storing audio data encoded in any of a plurality of different audio encoding formats is enabled by parametrically defining the underlying format in which the audio data is encoded, in audio format and packet table chunks. A flag can be used to manage storage of the size of the audio data portion of the file, such that premature termination of an audio recording session does not result in an unreadable corrupted file. This capability can be enabled by initially setting the flag to a value that does not correspond to a valid audio data size and that indicates that the last chunk in the file contains the audio data. State information for the audio data, to effectively denote a version of the file, and a dependency indicator for dependent metadata, may be maintained, where the dependency indicator indicates the state of the audio data on which the metadata is dependent.

BENEFIT CLAIM

This application claims benefit as a Continuation of application Ser.No. 10/883,898, filed Jul. 2, 2004 the entire contents of which ishereby incorporated by reference as if fully set forth herein, under 35U.S.C. §120. The applicant(s) hereby rescind any disclaimer of claimscope in the parent application(s) or the prosecution history thereofand advise the USPTO that the claims in this application may be broaderthan any claim in the parent application(s).

TECHNICAL FIELD

The present invention relates generally to digital audio and, morespecifically, to a universal container for audio data.

BACKGROUND

Standard AIFF, AIFC and WAVE files, which consist of “chunks” ofinformation, are limited to 4 gigabytes. High-resolution audio is nowdemanding that larger file sizes be possible. For example a 4 gigabytefile with 5.1 (i.e., 6 channels) at 96 KHz sample rate and 24 bits persample has 41 minutes of play time, and a 4 gigabyte file with 5.1 at192 KHz sample rate and 32 bit floating point per sample has 15 minutesof play time. With 8, 16, 32 or more channels, the play times becomeeven shorter.

With AIFF and WAVE files, an audio application has two options whenrecording. The first option is to record the audio data and then updatethe audio data size field in the file at the end of the recordingsession. Applications rely on the size field to correctly parse thefile. Thus, if an audio application were to terminate prematurely, orthere was a power loss while recording, most applications would beunable to read the file because the size field would be incorrect. Thesecond option is to update the size field repeatedly while audio data iswritten to the file. This process requires significant interactions withthe hard disk on which the file is being stored, which significantly andnegatively affects performance. Furthermore, if the recordingapplication were to terminate in the midst of updating the size field,the file is also corrupt and unable to be read properly.

With the evolution and complexity of modern audio formats, a moregeneric and robust means needs to be developed to contain these formats.Based on the foregoing, there is a need for an audio file format thatavoids the above-identified limitations of existing audio formats.

The approaches described in this section are approaches that could bepursued, but not necessarily approaches that have been previouslyconceived or pursued. Therefore, unless otherwise indicated, it shouldnot be assumed that any of the approaches described in this sectionqualify as prior art merely by virtue of their inclusion in thissection.

BRIEF DESCRIPTION OF THE DRAWINGS

Embodiments of the present invention are illustrated by way of example,and not by way of limitation, in the figures of the accompanyingdrawings and in which like reference numerals refer to similar elementsand in which:

FIG. 1 is a block diagram that illustrates a general layout of an audiofile, according to an embodiment of the invention;

FIG. 2 is a flow diagram that illustrates a first method for handlingaudio information, according to an embodiment of the invention;

FIG. 3 is a flow diagram that illustrates a second method for handlingaudio information, according to an embodiment of the invention; and

FIG. 4 is a block diagram that illustrates a computer system upon whichan embodiment of the invention may be implemented.

DETAILED DESCRIPTION

In the following description, for the purposes of explanation, numerousspecific details are set forth in order to provide a thoroughunderstanding of embodiments of the present invention. It will beapparent, however, that embodiments of the present invention may bepracticed without these specific details. In other instances, well-knownstructures and devices are shown in block diagram form in order to avoidunnecessarily obscuring embodiments of the present invention.

Universal Containment Overview

A universal and extensible container format for audio data (referred toas XAF: Extensible Audio Format) is described, which provides amechanism for storing audio data encoded in any of a plurality ofdifferent audio encoding formats.

In one aspect of the invention, the underlying format in which the audiodata is encoded is parametrically defined in an audio format chunk,encapsulating all the information for describing the basic formatproperties of a stream of audio data. Basic parameters define theproperties of an audio stream sufficient to describe any constant bitrate audio format that has channels that are the same size. Additionalparameters, defined in a packet table chunk, can be used to describeproperties of an audio stream sufficient to describe any variable bitrate format. Based on the specified parameters, the audio data may beaccessed and manipulated even when the actual encoding format is notknown to the software performing such manipulation. This may be thecase, for example, when the audio data is encoded in a format that wasdeveloped after the software used to manipulate the audio data. Hence,the container is universal, and extensible, in that it can be used tostore audio data in any encoded format, including those presently knownas well as those not yet developed. Consequently, any parsers, readers,editors or players of XAF files do not require specific software codefor each different audio encoding format that may be contained within anXAF file.

Audio Data Block Size Overview

In another aspect of the invention, a flag is used to manage storage ofthe size of the audio data portion of the file, such that prematuretermination of an audio recording session does not result in anunreadable corrupted file. Consequently, restarting the recording of theaudio data in another recording session can begin recording where theprevious session left off.

In one embodiment, this audio size management capability is enabled byinitially setting the flag to a value that does not correspond to avalid audio data size and that indicates that the last chunk in the filecontains the audio data. Preferably, the flag is updated to a value thatrepresents the actual audio data size upon successful completion of therecording. Thus, while parsing a file, (1) if the flag has the valuethat does not correspond to a valid audio data size, then the actualaudio data size can be determined based on the size of the audio fileand a starting position of the last chunk of the file; and (2) if theflag has a value that is a valid audio data size and that represents theactual audio data size, then the actual audio data size can bedetermined from the flag. If the flag is not updated to a value thatrepresents the actual audio data size, then the actual audio data sizecan still be determined based on the size of the audio file and astarting position of the last chunk of the file. The foregoing techniquealso provides for adding audio data to an existing audio data chunk andfor adding metadata chunks after the audio data chunk.

Dependency Tracking Overview

A given audio file, contained according to the universal containerformat described herein, may include metadata that is dependent on theassociated audio data. For example, an overview chunk of the audio filemay be used to store information representing an overview of the audiodata. In one aspect of the invention, state information for the audiodata is maintained in the audio file to effectively denote a version ofthe file. A dependency indicator is stored for the dependent metadata,where the dependency indicator indicates the state of the audio data onwhich the metadata is dependent. Hence, it is determinable, at any giventime, whether metadata is valid by comparing the dependency indicatorfor the metadata with the current state information of the audio data.

The foregoing overviews show that the XAF file format simplifies andcanonizes both (1) the different types of audio data and (2) the kindsof information that are commonly stored with that audio data. The XAFformat provides 64 bit file support, thereby enabling files havinglonger audio duration than is available with other audio formats and, inone embodiment, multiple channels of audio within a single file areinterleaved.

DEFINITION OF TERMS

Some terms that are used herein are defined as follows.

Sample—One number from one channel.

Frame—One sample for each channel. For example, a frame of stereo audiois two samples, one sample for each of the left and right channels.

Packet—For PCM, one frame. For compressed formats it is something thatwill decompress to some number of frames. For example, a packet of AACdecompresses to 1024 frames of PCM.

Sample Rate—The number of frames that occur every second. For example,the sample rate for common compact discs (CDs) is 44.1 KHz, or 44100frames per second (one left channel sample and one right channel samplefor each frame). The term “sample rate” is used herein as in common use,however, more accurately in that herein the sample rate is the framerate, which represents the number of n channels of samples per second.Thus, a common stereo CD plays at 44.1 KHz, which is actually 88200samples per second.

In the world of codecs, the word “frame” is often used to describe adiscrete packet of encoded data. However, the term “packet” is usedherein to describe a discrete unit of encoded data. As such, in anencoded audio format, a packet represents the smallest, indivisibleblock of audio data. In summary, (a) a packet consists of one or moreframes, depending on the format; (b) a frame is made up of n channels ofsamples; and (c) the sample rate describes the number of frames ofsamples per second.

Overview of Audio Formats

Non-limiting examples of audio formats that can be described using theXAF format include the following:

(A) PCM—8, 12, 16, 24, 32 bit signed integer; 32, 64 bit floatinginteger, in either big or little endian orderings;

(B) Constant Bit Rate Encoded Audio (e.g., IMA);

(C) Constant Frame, Variable Bit Rate (e.g., AAC, MP3); and

(D) Variable Frame, Variable Bit Rate per encoded packet.

Audio data in an XAF file is primarily handled as a packet. The contentof an audio data packet differs substantially based on the audioencoding format, but the general approach to reading and writing audiodata to an XAF file does not.

Packet Types

(A) Constant Bit Rate Formats

Constant bit rate (“CBR”) packet types are supported with the XAFformat, such as with PCM, PWM, and CBR compressed formats. With CBRformats, the XAF format chunk completely describes the size of eachpacket of data, and thus a parser can both read and write any packetwith no further information.

(B) Variable Bit Rate Formats

With variable bit rate (“VBR”) packet types, through the provision of apacket chunk, a parser can both read and write packets to an XAF filewithout knowing anything about the construction of the bits within theseindividual packets, regardless of the encoding format of the audio data.In one embodiment, with any audio data encoding format in which an XAFformat chunk cannot completely de-lineate the packet boundaries, apacket chunk is used, as described hereafter.

(C) Compressed Formats

VBR data formats can be either internally or externally framed. That is,the boundaries of each packet of audio data is either described withinthe data stream (internally framed), or is an addendum to the stream(externally framed). MP3, for example, is internally framed, and usessynch markers to add integrity to packet marks. MPEG 4-AAC is externallyframed, in that the packet boundaries are stored externally to the datastream.

With externally framed packets, there is no need to provide specialknowledge to a particular bit stream in order to parse that bit stream,while either reading or writing the file. Furthermore, when data isinternally framed, the parser has to parse the entire data segment toknow where packet boundaries are, how long the file is, etc., whichimposes a considerable cost when opening a file to be read (which is byfar the most common practice).

The format of each packet of a compressed format in an XAF file willhave a described data format, which is typically described by theStandards or Industry body that has responsibility for the compressedformat. For example, MP3 (to be precise, MPEG1 & 2, Layer 3) packetformat contains (1) Start: Start of Synch Word; and (2) End: byte beforethe beginning of the Next Synch Word. For another example, AAC utilizesMPEG4 Defined Access Unit. However, as a parser of an XAF file, the soleresponsibility is to read and write the packets, based on the boundariesdescribed by the packet table. The codec, as the generator or consumerof these packets, is responsible for providing and consuming audio datahaving the specified constructions.

Specific Types of XAF Chunks

In one embodiment, the data structure values found within an XAF fileare in network (big-endian) order. In one embodiment, standard-specifiedchunks are delineated (including the mFileType ID) with lower casecharacters, i.e., using characters only within the ASCII range of ‘a’ to‘z’, including both the <space> and ‘.’ characters. In one embodiment,user-defined chunk types or information keys include at least one bytevalue outside of the foregoing range in the 4 byte mChunkType field ofan XAF Chunk Header. In one embodiment, users adding chunk definitionsuse the ‘uuid’ chunk type and semantics as described below.

Preferred Chunks

An XAF file may contain various types of chunks of information. Some ofthe types of chunks available for an XAF file are referred to as“preferred” chunks in that they are considered fundamental chunks of anXAF file, necessary for capturing some fundamental features offered bythe XAF file format.

The preferred chunks include the following, each of which is describedhereafter:

(A) XAF File Header Chunk;

(B) Format Chunk, which comprises a description of the attributes (i.e.,parameters) of the audio stream, according to the underlying encodingscheme in which the audio data is encoded; and

(C) Data Chunk, which comprises the actual audio data. In oneembodiment, the size of the data chunk may be unspecified or set to aninvalid size (e.g., set to a value of −1), which indicates that the datachunk is the last chunk in the file and that all the content from thestart of the data chunk to the end of the file is audio data. If thesize is greater than zero, then there can be additional chunks after thedata chunk, and the size is used to determine the actual size of thecontained audio data.

In addition, with VBR data, a packet table chunk is used. Furthermore, amagic cookie chunk is used if it is required by the format, as describedhereafter.

In one embodiment, the file header chunk, format chunk and data chunkare all required for an XAF file.

Recommended Chunk

As mentioned, an XAF file may contain various types of chunks ofinformation, with preferred chunks considered the chunks that capturefundamental aspects of the XAF file format. Additional aspects of theXAF file format can be captured by using one or more types of chunksreferred to as “recommended” chunks, in that they are recommended foruse in an XAF file.

One recommended chunk is as follows, which is described in more detailhereafter.

(A) Channel Descriptions Chunk. A channel description describes themeanings and orderings of the channels contained within the XAF file.For single channel or dual channel data, the absence of a channeldescriptions chunk implies mono or stereo (left/right) audio,respectively. The channel descriptions chunk is described in more detailhereafter.

An additional recommendation is that the data size in the data chunk iscorrectly set to the actual size of the audio data.

Optional Chunks

Additional aspects of the XAF file format can be captured by using oneor more types of chunks referred to as “optional” chunks, in that theyare optional for use in an XAF file. One or more optional chunks may beused in an XAF file to provide a more feature-rich audio file. Theoptional chunks are listed below, with each described in more detailhereafter.

(A) Markers Chunk;

(B) Regions Chunk;

(C) Overview Chunk;

(D) Peak Chunk;

(E) UMID Chunk;

(F) Information Chunk;

(G) Edit Comments Chunk; and

(H) MIDI Chunk.

General XAF File Layout

XAF File Layout Example

FIG. 1 is a block diagram that illustrates a general layout of an audiofile, according to an embodiment of the invention. Audio file 100comprises a set of chunks of information, generally including audio dataand metadata. FIG. 1 illustrates some of the possible chunks that may bepresent in an XAF audio file. However, the depiction of audio file 100is not an exhaustive illustration of all of the chunks that may bepresent in such a file, nor are all of the chunks depicted in audio file100 necessary for all embodiments of the invention. The order in whichthe chunks are depicted in audio file 100 is arbitrary, unless otherwiseindicated herein.

Referencing from right to left, audio file 100 comprises a data chunk102, a channel descriptions chunk 112, an overview chunk 122, a formatchunk 132 and a packet table chunk 142, each of which are described indetail herein.

Data chunk 102 comprises a data chunk header 104, audio data 106, andstate information 110. The data chunk header 104 comprises variousinformation, or metadata, such as an audio data chunk size flag 108(referred to as mChunkSize elsewhere herein). Audio data chunk size flag108 (as well as similar flags for each chunk) contains a value that, attimes, indicates the size of the audio data 106. Other values containedin audio data chunk size flag 108 may have other meanings, such as theuse in one embodiment of “−1” for the audio data chunk size flag 108, toindicate that the data chunk 102 is the last chunk in audio file 100(described in more detail herein). State information 110 containsinformation that identifies the current version of the audio data 106 indata chunk 102. As described in more detail herein, state information110 can be compared against a dependency indicator from other chunksthat are dependent on (e.g., derived from) audio chunk 102 (such asdependency indicator 124 from overview chunk 122), to determine whetherinformation in the dependent chunk is still valid in view of the currentversion of the audio data 106.

Channel description chunk 112 contains a set of audio channeldescriptions, which, in one embodiment, specify both the order and thelocation (i.e., the role or usage) of each of the channels that arecontained within the file. Channel descriptions chunk 112 is describedin more detail herein.

As mentioned, in one embodiment, overview chunk 122 contains adependency indicator 124, which indicates a version of information fromwhich overview data, such as derived statistics 126, are derived. Forexample, derived statistics 126 are derived from a particular version ofaudio data 106, which is identified by state information 110, and areassociated with dependency indicator 124. Thus, if state information 110of audio chunk 102 matches dependency indicator 124 of overview chunk122 (or any other similarly functioning dependency indicator from anyother chunk in audio file 100 that is dependent on audio data 106), thenthe overview information in overview chunk 122 can be considered stillvalid, as derived. Overview chunk 122 is described in more detailherein.

Packet table chunk 132 is used for VBR encoding formats. The packettable chunk 132 expresses the characteristics of the encoded bit stream,such as the audio stream's (1) duration in sample frames, (2) anyadditional priming frames, and (3) remainder frames, each of which isdescribed in more detail herein. Packet table chunk 112 is described inmore detail herein.

Format chunk 142 contains information that describes the format of theaudio data contained within the file, i.e., audio data 106. Format chunk142, along with packet table chunk 132, enables the self-describing,(i.e., universal) functionality of an XAF audio file, such as audio file100, so that software processing such an audio file is not required toknow, a priori, about the particular format in which the audio data isencoded. Format chunk 142 is described in more detail herein.

XAFFileHeader

In one embodiment, an XAF file begins with a file header,“XAFFileHeader”, which can be structured as depicted hereafter. The fileheader is followed by a series of chunks of data or metadata. In oneembodiment, the values contained in the fields of the file header areordered in big endian order.

struct XAFFileHeader {   UInt32  mFileType;  // ‘.xaf’  UInt16  mFileReserved;   UInt16  mFileVersion; };

XAFChunkHeader

In one embodiment, every chunk is preceded by a chunk header (e.g., datachunk header 104 of FIG. 1), “XAFChunkHeader”, which can be structuredas depicted hereafter. In one embodiment, the values contained in thefields of the chunk header are ordered in big endian order.

struct XAFChunkHeader { UInt32 mChunkType; UInt16 mChunkFlags; UInt16mChunkVersion; SInt64 mChunkSize; };where,

mChunkType is the type of chunk for which the chunk header applies,which, in one embodiment, is a four character, big endian ordered code;

mChunkFlags are used to describe any differences in the data of a chunkthat can affect how a given chunk's data would be interpreted;

mChunkVersion is used to provide a version number of a chunk's format.It is conceivable that a given chunk's format may be different in afuture revision of the XAF file format, in which case the version of thechunk would be revised to reflect such changes.

mChunkSize is the size of the data chunk that follows, not includingthis header, which, in one embodiment, is represented in a number ofbytes.

Format Description

In one embodiment, the first chunk after the file header is the formatchunk (e.g., format chunk 142 of FIG. 1), “XAFAudioFormat”, whichdescribes the audio encoding format using parameter values. In oneembodiment, the format chunk must precede the audio data chunk. In oneembodiment, the header for the format chunk, “formatChunkHeader”, isstructured as depicted hereafter.

formatChunkHeader

XAFChunkHeader formatChunkHeader;

formatChunkHeader.mChunkType=‘desc’;

formatChunkHeader.mChunkFlags=0;

formatChunkHeader.mChunkVersion=0;

formatChunkHeader.mChunkSize=32;

where,

the mChunkType field identifies the type of chunk as a description(i.e., format description) chunk; and

the mChunkSize field identifies the chunk size as 32 bytes.

In the foregoing example header, both the flags and version fields ofthe format chunk header are set to a default value of zero.

XAFAudioFormat

An audio format chunk, “XAFAudioFormat”, follows the format chunkheader. The audio format chunk describes the format of the audio datacontained within the file. In one embodiment, the audio format chunk isstructured as depicted hereafter.

struct XAFAudioFormat { Float64 mSampleRate; UInt32 mFormatID; UInt32mFormatFlags; UInt32 mBytesPerPacket; UInt32 mFramesPerPacket; UInt32mChannelsPerFrame; UInt32 mBitsPerChannel; };

The audio format chunk encapsulates all the information necessary fordescribing the basic format properties of a stream of audio data. Thisinformation included in the audio format structure is sufficient todescribe any constant bit rate format that has channels that are thesame size. Additional information is required for variable bit ratedata, as described hereafter in reference to the Packet Table chunk. Avalue of “0” indicates that the field is either unknown, not applicable,or is otherwise inappropriate for the format and should be ignored. Notethat “0” can be a valid value for some formats in the mFormatFlagsfield.

Each of the parameter fields in the audio format chunk is describedhereafter.

mSampleRate—The number of sample frames per second of the audio data inthe audio stream. In one embodiment, this is an IEEE-754 floating pointrepresentation.

mFormatID—A four character code indicating the general kind of data inthe stream.

mFormatFlags—Flags specific to each format.

mBytesPerPacket—The number of bytes in a packet of data.

mFramesPerPacket—The number of sample frames in each packet of data.

mChannelsPerFrame—The number of channels in each frame of data.

mBitsPerChannel—The number of bits of sample data for each channel in aframe of data.

mformatID

The following are defined values for the mFormatID field. This is anexemplary, non-exhaustive and non-limiting list of values.

enum { kAudioFormatLinearPCM = ‘lpcm’, kAudioFormatAppleIMA4 = ‘ima4’,kAudioFormatMPEG4AAC = ‘aac ’, kAudioFormatMACE3 = ‘MAC3’,kAudioFormatMACE6 = ‘MAC6’, kAudioFormatULaw = ‘ulaw’, kAudioFormatALaw= ‘alaw’, kAudioFormatMPEGLayer3 = ‘.mp3’, kAudioFormatAC3 = ‘ac-3’,kAudioFormat60958AC3 = ‘cac3’ };

Each of the foregoing values for the mFormatID field is describedhereafter.

kAudioFormatLinearPCM—Linear PCM, uses the PCM related flags discussedbelow.

kAudioFormatAppleIMA4—Apple's implementation of IMA 4:1 ADPCM; has noflags.

kAudioFormatMPEG4AAC —MPEG-4 AAC; the flags field contains the MPEG-4audio object type constant indicating the specific kind of data.

kAudioFormatMACE3—MACE 3:1; has no flags.

kAudioFormatMACE6—MACE 6:1; has no flags.

kAudioFormatULaw—μLaw 2:1; has no flags.

kAudioFormatALaw—aLaw 2:1; has no flags.

kAudioFormatMPEGLayer3—MPEG-1 or −2, Layer 3 audio; has no flags.

kAudioFormatAC3—AC-3; has no flags.

kAudioFormat60958AC3—AC-3 packaged for transport over an IEC 60958compliant digital audio interface; uses the standard flags for thisformat.

mFormatFlags

For formats that require further delineation, the mFormatFlags field isused. In cases where there is no further delineation, this field shouldbe set to zero. Any flags that are not specified for any of thepublished formats are reserved for future use. For compatibility, thoseflag bits (or flag values) should be set to zero. The following aredefined values for the mFormatFlags field. This is an exemplary,non-exhaustive and non-limiting list of values.

(A) Linear PCM Flags:

enum   {     kXAFLinearPCMFormatFlagIsFloat   = (1L << 0),    kXAFLinearPCMFormatFlagIsLittleEndian  = (1L << 1) };

Each of the foregoing values for the mFormatFlags field is describedhereafter. The flags field for Linear PCM, when set to zero, representsinteger, big endian sample format.

kXAFLinearPCMFormatFlagIsFloat—Set for floating point, clear forinteger.

kXAFLinearPCMFormatFlagIsLittleEndian—Set for little endian, clear forbig endian.

(B) AAC Flags

These flags take on the MPEG-4 Audio Object types that are defined forAAC.

enum   {     kMP4Audio_AAC_Main_ObjectType = 1,    kMP4Audio_AAC_LC_ObjectType = 2,     kMP4Audio_AAC_SSR_ObjectType =3,     kMP4Audio_AAC_LTP_ObjectType = 4,    kMP4Audio_AAC_Scalable_ObjectType = 6,    kMP4Audio_ER_AAC_LC_ObjectType = 17,    kMP4Audio_ER_AAC_LTP_ObjectType = 19,    kMP4Audio_ER_AAC_Scalable_ObjectType = 20   };

Each of the foregoing values for the mFormatFlags field is describedhereafter.

kMP4Audio_AAC_Main_ObjectType—AAC Main Object.

kMP4Audio_AAC_LC_ObjectType—AAC Low Complexity Object.

kMP4Audio_AAC_SSR_ObjectType—AAC Scalable Sampling Rate Object.

kMP4Audio_AAC_LTP_ObjectType—AAC Long Term Predictor Object.

kMP4Audio_AAC_Scalable_ObjectType—AAC Scalable Object.

kMP4Audio_ER_AAC_LC_ObjectType—Error Resilient(ER) AAC LowComplexity(LC) Object.

kMP4Audio_ER_AAC_LTP_ObjectType—Error Resilient(ER) AAC Long TermPredictor(LTP) Object.

kMP4Audio_ER_AAC_Scalable_ObjectType—Error Resilient(ER) AAC ScalableObject.

Any other values used for the flags field will be dependent on anyfuture revisions of AAC object types by the MPEG-4 standards bodies.

Format Chunk Examples

The following variations of PCM audio should be supported by all XAFparsers: (1) any sample rate; (2) samples of 16, 24 and 32 bit signedinteger (both big and little endian); and (3) samples of 32 and 64 bitfloat (both big and little endian). In one embodiment, the floatingpoint values are conformant to the IEEE-754 specification.

There are two possible ways that 24 bit samples are stored within afile, and both are reasonably common: (1) packed within 3 bytes; and (2)packed within a 4 byte container. Both ways of packing are describedhereafter.

Linear PCM

This example is for 16 bit, big-endian stereo, 44.1 KHz audio data. Forall PCM formats the bytesPerPacket and framesPerPacket are equivalent(i.e., 1) because, by definition, PCM formats are one frame per packet.

XAFAudioFormat simplePCM16;

simplePCM16.mSampleRate=44100;

simplePCM16.mFormatID=kAudioFormatLinearPCM;

simplePCM16.mFormatFlags=0; // big endian integer;

simplePCM16.mChannelsPerFrame=2;

simplePCM16.mBitsPerChannel=16;

simplePCM16.mFramesPerPacket=1;

simplePCM16.mBytesPerPacket=4;

The next example is for 24 bit, little-endian stereo, 48 KHz audio data.

XAFAudioFormat simplePCM24;

simplePCM24.mSampleRate=48000;

simplePCM24.mFormatID=kAudioFormatLinearPCM;

simplePCM24.mFormatFlags=kXAFLinearPCMFormatFlagIsLittleEndian;

simplePCM24.mChannelsPerFrame=2;

simplePCM24.mBitsPerChannel=24;

simplePCM24.mFramesPerPacket=1;

simplePCM24.mBytesPerPacket=6;

In this case, the 24 bits are packed within their containing bytes(i.e., each 24 bit sample takes up 3 bytes in the file). It is alsocommon to reserve 4 bytes per sample for 24 bits. In this case the 24bits are aligned high within the 4 byte field. The format for this wouldbe described as:

XAFAudioFormat sparsePCM24;

sparsePCM24.mSampleRate=48000;

sparsePCM24.mFormatID=kAudioFormatLinearPCM;

sparsePCM24.mFormatFlags=kXAFLinearPCMFormatFlagIsLittleEndian;

sparsePCM24.mChannelsPerFrame=2;

sparsePCM24.mBitsPerChannel=24;

sparsePCM24.mFramesPerPacket=1;

sparsePCM24.mBytesPerPacket=8;

As with non-byte aligned sample widths, described hereafter, the samplesare high aligned within its containing byte width. A parser can thenhandle this as if it were 32 bit integer (as the lowest, or leastsignificant 8 bits will all be zero). On disk, this looks like: (MM ismost significant byte, LL is least significant, XX is mid, and 0 isunused)

00 LL XX MM

A big-endian ordered version of the same layout (24 bit audio in 4bytes) looks like:

MM XX LL 00

The next example is for 32 bit float, big-endian 6 channels of 96 KHzaudio data.

XAFAudioFormat simplePCM96;

simplePCM96.mSampleRate=96000;

simplePCM96.mFormatID=kAudioFormatLinearPCM;

simplePCM96.mFormatFlags=kXAFLinearPCMFormatFlagIsFloat;

simplePCM96.mChannelsPerFrame=6;

simplePCM96.mBitsPerChannel=32;

simplePCM96.mFramesPerPacket=1;

simplePCM96.mBytesPerPacket=24;

The next example is for 64 bit float, little-endian 4 channels of 192KHz audio data.

-   -   XAFAudioFormat simplePCM192;    -   simplePCM192.mSampleRate=192000;    -   simplePCM192.mFormatID=kAudioFormatLinearPCM;    -   simplePCM192.mFormatFlags=kXAFLinearPCMFormatFlagIsFloat|kXAFLinearPCMFormatFlagIsLittleEndian;    -   simplePCM192.mChannelsPerFrame=4;    -   simplePCM192.mBitsPerChannel=64;    -   simplePCM192.mFramesPerPacket=1;    -   simplePCM192.mBytesPerPacket=32;

IMA4

When describing compressed formats in XAF file format (whether variableor constant bit rates and/or frames per packet), the format chunkdescribes in some part what the result of decompressing the compressedpackets will provide. Thus, the format chunk contains the number ofchannels and the sample rate.

IMA4 is a constant bit rate, constant frames per packet format, which isdescribed in the format chunk as follows.

mSampleRate indicates the sample rate of a single frame of the audioencoded in the compressed packets;

mChannelsPerFrame describes the number of channels encoded in thecompressed packets;

mFramesPerPacket represents the number of frames encoded in eachcompressed packet;

mBitsPerChannel is zero; and

mBytesPerPacket is a non-zero value.

IMA is shown for purposes of example, however, the foregoing conditionsare true for any format of this nature. As a point of information, IMA4always encodes 64 sample frames into a single packet of 34 bytes perchannel. Thus the bytesPerPacket is the channelsPerFrame*34. Thus, IMA4data that will provide 44.1 KHz, stereo audio, can be described asfollows:

XAFAudioFormat imaDesc;

imaDesc.mSampleRate=44100;

imaDesc.mFormatID=kAudioFormatAppleIMA4;

imaDesc.mFormatFlags=0;

imaDesc.mChannelsPerFrame=2;

imaDesc.mBitsPerChannel=0;

imaDesc.mFramesPerPacket=64;

imaDesc.mBytesPerPacket=imaDesc.mChannelsPerFrame*34;

AAC

MPEG-4 AAC is by definition a variable bit rate, constant frames perpacket format. MP3 has varieties that are both CBR (similar to the IMAexample above), as well as VBR (similar to this example). For audioformats that provide variable bit rate, constant frames per packets, thefollowing information is used to describe the format:

mSampleRate indicates the sample rate of a single frame of the audioencoded in the compressed packets;

mChannelsPerFrame describes the number of channels encoded in thecompressed packets;

mFramesPerPacket represents the number of frames encoded in eachcompressed packet;

mBitsPerChannel is zero;

mBytesPerPacket is zero, which indicates that the number of bytescontained in each packet is variable.

Thus, a file containing MPEG-4 AAC (using the Low Complexity AudioObject format), where the encoded data represents 44.1 KHz, stereoaudio, can be described as follows:

XAFAudioFormat aacDesc;

aacDesc.mSampleRate=44100;

aacDesc.mFormatID=kAudioFormatMPEG4AAC;

aacDesc.mFormatFlags=kMP4Audio_AAC_LC_ObjectType;

aacDesc.mChannelsPerFrame=2;

aacDesc.mBitsPerChannel=0;

aacDesc.mFramesPerPacket=1024;

aacDesc.mBytesPerPacket=0;

The duration of each packet for both the IMA and AAC type of audio canbe calculated by dividing mSampleRate by mFramesPerPacket.

Variable Bit Rate, Variable Frames Per Packet

Some encoded audio formats encode packets that are not only of avariable data size, but are also encoded with a variable number offrames per packet of uncompressed audio source (which will generate avariable number of frames when decompressed). For a format of thisnature, the following information applies:

mSampleRate indicates the sample rate of a single frame of the audioencoded in the compressed packets;

mChannelsPerFrame describes the number of channels encoded in thecompressed packets;

mFramesPerPacket is zero, which indicates that the number of framescontained in each packet is variable;

mBitsPerChannel is zero;

mBytesPerPacket is zero, which indicates that the number of bytescontained in each packet is variable.

An example variable bit rate, variable frames per packet audio file canbe described as follows:

XAFAudioFormat vbr_vfp_Desc;

vbr_vfp_Desc.mSampleRate=sampleRateOfAudio;

vbr_vfp_Desc.mFormatID=kVariableFramesPerPacket;

vbr_vfp_Desc.mFormatFlags= . . . ; // any flags appropriate to theformat

vbr_vfp_Desc.mChannelsPerFrame=numberOfChannelsOfAudio;

vbr_vfp_Desc.mBitsPerChannel=0;

vbr_vfp_Desc.mFramesPerPacket=0;

vbr_vfp_Desc.mBytesPerPacket=0;

Formats that are Not Byte Aligned

An applicable assumption (as is true of existing MPEG audio formats) isthat compressed audio formats are byte aligned. However, in someinstances, that assumption does not hold true.

Linear PCM

Some PCM bit depths are not byte aligned, for example, 12 bit or 18 bitPCM audio. These formats should adhere to the following requirements:(1) the format is packed within a byte aligned sample width; and (2) thesamples are aligned high within the enclosing byte-aligned width. Thus,12 bit PCM audio data (in the case below, this is big endian) is packedwithin a 2 byte (16 bit) word, and would be presented as:

XAFAudioFormat PCM12;

PCM12.mSampleRate=44100;

PCM12.mFormatID=kAudioFormatLinearPCM;

PCM12.mFormatFlags=0; // big endian integer

PCM12.mChannelsPerFrame=2;

PCM12.mBitsPerChannel=12;

PCM12.mFramesPerPacket=1;

PCM12.mBytesPerPacket=4;

A similar scheme would be followed for 18 bit PCM data, where the audiodata may be aligned high within a 3 byte (24 bit) word. This allowsparsers of this format (except in the case where they take specialadvantage of the bit depth of the samples) to parse and convert thesample data using the same algorithms as for their byte-aligned format.Thus, in the 12 bit case above, code that parses 16 bit packed data canalso parse 12 bit sample data, treating it in the same manner.Specifying that the data is actually 12 bit can present some advantageswith some uses of this audio data.

PWM

PWM is a format in which each sample is one bit. PWM is used as the dataformat of SACD (Super Audio CD). The following describes how PWM stereodata would be packed and described in an XAF file.

XAFAudioFormat pwmDesc;

pwmDesc.mSampleRate=2822400;

pwmDesc.mFormatID=kAudioFormatPWM; // ‘pwm’

pwmDesc.mFormatFlags=0;

pwmDesc.mChannelsPerFrame=2;

pwmDesc.mBitsPerChannel=1;

pwmDesc.mFramesPerPacket=8;

pwmDesc.mBytesPerPacket=2;

The sample rate for a SACD bit stream is 2.8224 MHz. There are no knownflags required for PWM format at this time. This particular stream is 2channels and there is 1 bit per channel. There are 8 frames per packetand, therefore, 2 bytes per packet (1 byte for each channel in thefile). Thus, PWM is packed as follows (in binary): LLLLLLLL RRRRRRRR.That is, one byte represents 8 individual channel values, and theinterleaving of each channel is done on the byte boundary (not on theindividual sample or bit boundary).

Audio Data Chunk

In one embodiment, an XAF file contains one and only one audio datachunk (e.g., data chunk 102 of FIG. 1), which follows the audio datachunk's header (e.g., data chunk header 104 of FIG. 1).

In one embodiment, the data chunk is set up as:

struct XAFData {   UInt32  mEditCount;   UInt8  mData[kVariableLengthArray]; };where,

mEditCount is information that identifies the current version of theaudio data, which is also referred to herein as “state information” forthe audio;

mData is a variable length field that contains the audio data (e.g.,audio data 106 of FIG. 1);

with an audio data chunk header as follows.

XAFChunkHeader dataChunkHeader;

dataChunkHeader.mChunkType=‘data’;

dataChunkHeader.mChunkFlags=0;

dataChunkHeader.mChunkVersion=0;

dataChunkHeader.mChunkSize=−1;

// set: mEditCount=0;

Audio Data Size Parameter

A “−1” value for mChunkSize indicates that the audio data proceeds fromthis part of the file to the end of the file. When a file is finalized,this field is preferably updated to reflect the real size of the audiodata chunk.

XAF allows an application to set the audio data chunk size field (e.g.,audio data chunk size flag 108, for audio data 106, of FIG. 1) to “−1”and record without performing a file seek to update this size field.When the program finishes recording, then the program can update thesound data chunk size field, mChunkSize. A file whose sound data chunksize field is set to “−1” is well defined and should be able to beopened by any program that supports XAF files. A file in this statemeans that the audio data chunk is the last chunk in the file and theaudio data extends from the beginning of that chunk to the end of thefile. Hence, an application can easily find the position, within astored file, of the end of the audio data, so that new chunks ofnon-audio metadata may be readily added to the file. If there are anyother chunks after the audio data, then the mChunkSize must at all timesbe valid. When reading a file, if the mChunkSize is set to less thanzero, then the reader should update this to the correct file size.

In one embodiment, an XAF file does not have the size of the file storedin its file header, like with AIFF or WAVE files. This information wouldbe redundant since the size of the file can be obtained from the filesystem or the transport layer.

FIG. 2 is a flow diagram that illustrates a method for handling audioinformation, according to an embodiment of the invention.

At block 202, audio data size information is read. For example, theaudio data chunk size flag 108 (FIG. 1), such as mChunkSize, is readfrom data chunk header 104 (FIG. 1), such as XAFChunkHeader, of datachunk 102 (FIG. 1).

At block 204, it is determined whether or not the size indicated in thesize information is a valid size for audio data, such as audio data 106(FIG. 1). If the indicated size is a valid size for audio data, then, atblock 206, audio data is accessed based on the indicated size. Forexample, if the audio data chunk size flag 108 (FIG. 1) indicates a sizegreater than zero, then audio data 106 (FIG. 1) is read from data chunk102 (FIG. 1). Otherwise, if the indicated size is not a valid size foraudio data, then it is assumed that the audio data chunk is the lastchunk in the audio file, and the entire audio file's size is used todetermine the size of the audio data. For example, a value of “−1” isindicated in the audio data chunk size flag 108, which indicates aninvalid size. Hence, the actual size of the audio data 106 can bedetermined based on a comparison between the size of the complete audiofile 100 (FIG. 1) (e.g., from the operating system or a file system) andthe starting point of the last chunk in the file, i.e., the audio chunk102.

Editing and Cross-Chunk Dependencies

XAF files can contain chunks that have dependencies on a particularstate of another chunk, typically the actual sound data stored withinthe data chunk. For example, overview data is generated based on theparticular contents of the sound data. Thus, if the sound data were tochange, that overview would be invalidated. To account for thissituation, the data chunk has an mEditCount field (e.g., stateinformation 110 of FIG. 1) that is incremented whenever a program editsthe contents of the audio data chunk, to identify the current state (orversion) of the audio data. In one embodiment, chunks that havedependencies on a particular state of the data chunk also have anmEditCount field (e.g., dependency indicator 124 of FIG. 1), which isset to the value of the mEditCount field of the data chunk at the timethat the dependent chunk is generated and, therefore, identifies thestate (or version) of the audio data from which the dependent chunk isderived.

The mEditCount field is initially set to zero when creating a new file.Any time the contents of the data chunk are edited in any way, the fieldmust be incremented by the editing program. More details of thisfunctionality are described herein in reference to the overview chunkand the peak chunk.

In one embodiment, chunk fields that have dependencies on a particularstate of the data chunk also have an mEditCount field, which is set tothe value of the mEditCount field of the data chunk at the time that thedependent field is populated and, therefore, identifies the state (orversion) of the audio data from which the dependent field is derived.

FIG. 3 is a flow diagram that illustrates a method for handling audioinformation, according to an embodiment of the invention.

At block 302, a dependency indicator is read from a chunk (referred toas “first chunk”, without implying that it is actually the first chunkin the audio file) from an audio file, where the chunk containsinformation that is dependent on another chunk in the audio file. Forexample, where derived statistics 126 (FIG. 1) from an overview chunk122 (FIG. 1) are dependent on, or derived from, audio data 106 (FIG. 1)of audio chunk 102 (FIG. 1), the dependency indicator 124 (FIG. 1)(e.g., mEditCount) is read from the overview chunk 122. In this example,dependency indicator 122 indicates from what version of audio data 106the derived statistics 126 were derived. In general, a dependencyindicator for a given chunk, or for a given parameter within a chunk,matches with state information associated with the version ofinformation on which the given chunk or parameter is dependent.

At block 304, state information is read from a chunk (referred to as“second chunk”, without implying that it is actually the second chunk inthe audio file) on which the other chunk (first chunk) is dependent. Forexample, the current state information 110 (FIG. 1) in data chunk 102(FIG. 1) is read, which indicates the current version of audio data 106(FIG. 1). Thus, at decision block 306, it is determined whether thedependency indicator and the status information match. For example, itis determined whether or not the mEditCount for the first chunk, whichis associated with at least some information in the first chunk, is thesame as the current mEditCount for the second chunk, the chunk on whichthe information in the first chunk depends.

If the dependency indicator and the state information match, then thatmeans that the information in the second chunk, on which the informationin the first chunk depends, has not been changed since the informationin the first chunk was generated. For example, the audio data 106(FIG. 1) from which the derived statistics 126 (FIG. 1) were generatedhas not changed since the derived statistics 126 were generated and,therefore, the derived statistics are still valid and consistent withthe audio data 106. Thus, at block 308, the existing metadata from thefirst chunk, or whatever information in the first chunk is dependent onthe second chunk, is used.

If the dependency indicator and the state information do not match, thenthat means that the information in the second chunk, on which theinformation in the first chunk depends, has been changed since theinformation in the first chunk was generated. For example, the audiodata 106 (FIG. 1) from which the derived statistics 126 (FIG. 1) weregenerated has changed since the derived statistics 126 were generatedand, therefore, the derived statistics may no longer be valid and may beinconsistent with the audio data 106. Thus, at block 310, new metadatais generated for the first chunk, or whatever information in the firstchunk is dependent on the second chunk. For example, the derivedstatistics 126 are regenerated or updated to reflect the current stateof the audio data 106, which is associated with the current stateinformation 110 (FIG. 1).

In addition, the dependency indicator is updated to reflect the newmetadata generated for the first chunk, at block 312. For example, thedependency indicator 124 (FIG. 1) (e.g., mEditCount) that is associatedwith the derived statistics 126 is updated to reflect the current stateinformation 110 (e.g., mEditCount) that is associated with audio data106, thereby indicating that the current derived statistics 126 areagain valid and consistent with the information on which the statisticsdepend, i.e., the audio data 106.

Packet Table Chunk

The Packet Table chunk (e.g., packet table chunk 132 of FIG. 1)expresses the characteristics of the encoded bit stream, i.e., the audiostream's (1) duration in sample frames, (2) any additional priming (whatcould be considered as latency), and (3) remainder frames (any paddingthat was performed in the encoding process to flush the last partialframes per packet samples). The packet table chunk is needed for VBRformats, in which the presence of a packet table chunk is determined bythe mBytesPerPacket field of the format chunk being zero.

In one embodiment, a Packet Table chunk is structured as follows.

struct XAFPacketTableHeader {   SInt64  mNumberPackets;   SInt32 mPrimingFrames;   SInt32  mRemainderFrames; };where,

mNumberPackets is the total number of packets of audio data contained inthe file;

mPrimingFrames is the number of frames that a packetized stream uses aspriming and/or processing latency;

mRemainderFrames is the number of frames that are left over from thelast packet. For example, an AAC bit stream may only have 313 framesthat are valid in its last packet. The frames per packet is 1024, so inthis case, mRemainderFrames is (1024-313), which represents that numberof samples that should be trimmed from the output of the last packetwhen decoding.

If an encoded bit stream is being edited, then it is recommended thatthe packets preceding the edit point that would account for at leastmPrimingFrames be taken with the edit to ensure a perfect reproductionof the audio from the edit point. Of course, when random accessingdifferent packets in a file for playback, the mPrimingFrames should beused to reconstruct the audio at the desired point.

In one embodiment, values in the packet descriptions use variable lengthencoded integers. Each byte contains 7 bits of size information, if thetop bit is set (i.e., the byte's value is >=128), then the next byte inthe stream contains the continuation of the size. The overall size isdetermined by finding a byte that has a value <127.

For example,

Value Representation  1 1 (Ox01) 1 Byte 127 127 (0x7F) 1 Byte 128 1 128(0x01 0x80) 2 Bytes 129 1 129 (0x01 0x81) 2 Bytes etc.

In one embodiment, the edit count semantic that is described inreference to some of the other chunks (e.g., overview chunk, peakchunk), is not applicable with the packet table chunk as its state mustalways be synchronized with any edits performed on the audio data.

Use with a Constant Bit Rate Format

In one embodiment, a packet chunk is present even with a constant bitrate (constant frames per packet and constant bytes per packet) formatto express one of two possible pieces of information: (1) any latency(mPrimingFrames) due to the nature of the codec; (2) any remainderframes, where the source material does not conform to the frames perpacket boundary of the codec. In this usage, mNumberPackets should beset to zero, and should be ignored by the parser. For example, IMAencodes samples into packet of 64 sample frames per packet. If thesource material was not equally divisible by 64 frames, then the lastpacket of IMA content will decode to less samples than the 64 that arepresented by the packet. Thus, an XAF file of IMA content could have apacket table where the last packet only has 5 valid samples, as follows:

mIMAPacketTable.mNumberPackets=0; // set to zero, ignored for codecswhere the desc's mBytesPerPacket!=0

mIMAPacketTable.mPrimingFrames=0; // has no latency

mIMAPacketTable.mRemainderFrames=59; // 64 (frames per packet)—5

This chunk's size in this case will be 16 as there are no packetdescriptions in a format of this type. This is an optional chunk forthis type of format.

Use with a Constant Frames per Packet Format

In one embodiment, the packet chunk is present when bytes per packet iszero and frames per packet is non-zero. The packet descriptions containone variable length integer to describe the number of bytes each packetcontains.

For example, given audio data encoded into AAC source of 3074 sampleframes, at 44.1 KHz (stereo), the format for is described as 1024 framesper packet and 0 bytes per packet. The data chunk will contain 6 AACpackets end to end, and the packet table chunk is as follows.

XAFChunkHeader packetChunkHeader;

dataChunkHeader.mChunkType=‘pakt’;

dataChunkHeader.mChunkFlags=0;

dataChunkHeader.mChunkVersion=0;

dataChunkHeader.mChunkSize=calc_sizeOfThePacketTable;

XAFPacketTableHeader packetTable;

packetTable.mNumberPackets=5;

packetTable.mPrimingFrames=2112;

packetTable.mRemainderFrames=958;

Following this would be 5 variable sized integers that describe thenumber of bytes for each of the 5 packets. The totalcalc_sizeOfThePacketTable would at least be the number of bytes used toencode the packet sizes plus 16 (sizeof(XAFPacketTableHeader)). In thisscenario, the following relationship of packets to its encoded/decodedframes is:

Packet: 1 2 3 4 5 6 Valid Frames: 0 0 960 1024 1024 66

Use with a Variable Frames Per Packet Format

In one embodiment (determined by the fact that the description has avalue of zero for both the frames per packet and bytes per packetentries), the packet descriptions contain two value for each packet(both encoded as a Variable Length Integer): (1) the number of framescontained within the packet; and (2) the size of the packet in bytes.

Some audio codecs (such as Main Profile AAC in MPEG-2, or AAC Long TermPrediction object in MPEG-4) use samples from both the preceding and thefollowing range that is going to be encoded in a particular encodedpacket. However, once encoded, there is no dependency in these packetsfor any data following the current packet, though there are dependencieson preceding packets, which is what the mPrimingFrames depicts.

If the audio format does not have a forward dependency in its encodedbit-stream, in one embodiment, the packet table chunk does not contain afield to depict such a dependency. If a format does have a forwarddependency in its encoded bit-stream, in one embodiment, the packettable chunk can be used to account for that.

Channel Descriptions Chunk

A channel descriptions chunk (e.g., channel descriptions chunk 112 ofFIG. 1) contains a set of audio channel descriptions, which, in oneembodiment, specify both the order and the location (i.e., the role orusage) of each of the channels that are contained within the file. Inone embodiment, the structure of a channel descriptions chunk is asfollows.

mChunkType = ‘chan’ struct AudioChannelDescription {  AudioChannelLabelmChannelLabel;  UInt32 mChannelFlags;  Float32 mCoordinates[3]; };

The number of channel descriptions contained in the channel descriptionschunk is the same as the number of channels specified in the formatchunk. The order of the channel descriptions describes the matchedchannel of audio data. That is, the first channel description describesthe first channel, the second channel description describes the secondchannel, and so on. The channel labels, coordinate specifications andflags are provided hereafter.

An XAF file with no channel descriptions can be interpreted as:

1 Channel—Mono

2 Channel—Stereo

>2 Channels—No implicit information is known about the channels or theirintended usage.

It is a common practice to split multi-channel mixes into a collectionof single channel files. In such a scenario, it is recommended that eachof these split (and, thus, inter-dependent) files contains a channeldescription that describes the intended use of that file's channel. Forexample, instead of a single stereo file, there are two files: one forthe left channel and one for the right channel. The left channel filehas a single channel description that labels the channel as a leftchannel, and the right channel file has a single channel descriptionthat labels the channel as the right channel. This avoids the fragilebut common practice of including this channel information solely in thename of the file.

In one embodiment, channel labels only describe the channel's label(left,

right, etc). The location of a channel based on a label is inferred fromthe standard location of that channel when so specified. For example,the description can also specify a location, in addition to the channellabel. This location can be the expected location for that label, or acustomized location appropriate for a given file's channel.

By specifying a label, parsing software can derive what generic channellayout is being presented by a file. For example, a 6 channel file thathas labels indicating left, right, left surround, right surround, centerand LFE can be presented as a file containing 5.1 content. Commonly-usedchannel layouts with their known channel constituents are presentedhereafter.

An Information chunk, described hereafter, also supplies a key for auser presentable name that represents the channel layout containedwithin the file.

Channel description definitions that may be used to identify channels,channel coordinate that may be used to specify the location thatrespective channels are to be presented, and common channel layouts aredescribed hereafter under the heading of “Miscellaneous Description.”

Optional Chunks

The following chunks are optional chunks in that they do not appear inall XAF files.

Free Chunk

mChunkType=‘free’

This is a padding chunk for reserving space in the file. The content ofthe Free chunk is meaningless.

Magic Cookie Chunk

mChunkType=‘kuki’

A magic cookie chunk contains private data required by the formatcontained in the file. Wherever possible, a magic cookie's structure isdefined by the format it describes. By defining and providingstandards-compliant “kuki's”, other code that parses and plays thesefiles are less likely to fail. Thus, for the following formats, wherepresent, the Magic Cookie is defined as:

MP3—no magic cookie (as it is not required by the data stream);

AAC—the ESDS as defined as codec specific data in the MPEG-4 definition.

As with the layout of the packetized data formats, the body or companythat owns or administers the audio format is also required to describethe format of the magic cookie (and even if it is needed), for thatformat. Furthermore, if a format is a proprietary format, then thatformat's owner should describe the magic cookie format and is alsoresponsible for any data versioning required of the magic cookie'scontents, i.e., the chunk header's version field is not to be used toversion different data formats of the data contained within a magiccookie.

Marker Chunk

XAF format provides a rich marker format (that is also used to defineRegions), which provides efficient and robust recording and editingcapabilities. Markers include SMPTE time stamps, as well as extensibleflags that can be used for containing information used when mastering.In one embodiment, a Marker chunk is structured as follows.

mChunkType = ‘mark’ // SMPTE Time Types enum {   kXAF_SMPTE_TimeType24 =1,   kXAF_SMPTE_TimeType25 = 2,   kXAF_SMPTE_TimeType30Drop  = 3,  kXAF_SMPTE_TimeType30 = 4,   kXAF_SMPTE_TimeType2997  = 5,  kXAF_SMPTE_TimeType2997Drop = 6,   kXAF_SMPTE_TimeType60 = 7,  kXAF_SMPTE_TimeType5994 = 8 }; struct XAF_SMPTE_Time {   UInt8 mHours;  UInt8 mMinutes;   UInt8 mSeconds;   UInt8 mFrames;   UInt32mSubFrameSampleOffset; }; typedef struct XAF_SMPTE_Time XAF_SMPTE_Time;struct XAFMarker {   UInt32 mMarkerSize; // length in bytes of themarker.   UInt32 mType;   Float64 mFramePosition;   SInt32 mMarkerID;  XAF_SMPTE_Time  mSMPTETime;   UInt16 mChannel;   UInt16 mReserved;  UInt8 mName[kVariableLengthArray]; // null terminated UTF8 string };typedef struct XAFMarker XAFMarker; // marker types // markersThe following is an exemplary, non-exhaustive and non-limiting list ofvalues for different marker types.

enum {  kXAFMarkerType_Generic = 0,  kXAFMarkerType_ProgramStart  =‘pbeg’,  kXAFMarkerType_ProgramEnd   = ‘pend’, kXAFMarkerType_TrackStart  = ‘tbeg’,  kXAFMarkerType_TrackEnd  =‘tend’,  kXAFMarkerType_Index = ‘indx’,  kXAFMarkerType_RegionStart  =‘rbeg’,  kXAFMarkerType_RegionEnd   = ‘rend’, kXAFMarkerType_RegionSyncPoint   = ‘rsyc’, kXAFMarkerType_SelectionStart  = ‘sbeg’,  kXAFMarkerType_SelectionEnd  = ‘send’,  kXAFMarkerType_EditSourceBegin = ‘cbeg’, kXAFMarkerType_EditSourceEnd = ‘cend’, kXAFMarkerType_EditDestinationBegin  = ‘dbeg’, kXAFMarkerType_EditDestinationEnd  = ‘dend’, kXAFMarkerType_SustainLoopStart = ‘slbg’, kXAFMarkerType_SustainLoopEnd = ‘slen’, kXAFMarkerType_ReleaseLoopStart = ‘rlbg’, kXAFMarkerType_ReleaseLoopEnd  = ‘rlen’ }; struct XAFMarkerChunk { UInt32 mSMPTE_TimeType;  UInt32 mNumberMarkers;  XAFMarkermMarkers[kVariableLengthArray]; } 3 typedef struct XAFMarkerChunkXAFMarkerChunk.

If the SMPTE time of a particular marker is not valid (i.e., not set),then all of the bytes used in the SMPTE Time for that marker should beset to “0xFF”, which is herein an invalid SMPTE time. If themSMPTE_TimeType is zero, then no markers will contain valid SMPTE times(i.e., all SMPTE Times must be marked invalid). If mSMPTE_TimeType isnon-zero, then this field indicates the frame rate axis of any validSMPTE times contained in a given marker. However, in such a scenario, amarker may still contain an invalid SMPTE time.

The mSubFrameSampleOffset field is provided so that SMPTE correlationsfor sample locations can be done sub-frame (and sample-accuratelysub-frame). It is a sample offset to the HH:MM:SS:FF time stamp.

Region Chunk

mChunkType = ‘regn’ struct XAFRegion {   UInt32 mNumberMarkers;  XAFMarker mMarkers[kVariableLengthArray]; }; typedef struct XAFRegionXAFRegion; struct XAFRegionChunk {   UInt32 mSMPTE_TimeType;   UInt32mNumberRegions;   XAFRegion mRegions[kVariableLengthArray]; } typedefstruct XAFRegionChunk XAFRegionChunk.

The meaning and interpretation of the mSMPTE_TimeType field is the sameas described for the marker chunk.

Overview Chunk

In XAF files, audio overview metadata (e.g., statistics regardingsamples of the audio data, such as maximum amplitude and minimumamplitude) are stored in an Overview chunk (e.g., derived statistics 126in overview chunk 122 of FIG. 1) within the same file as the actualaudio data. In one embodiment, the structure of the Overview chunk is asfollows.

mChunkType = ‘ovvw’ struct XAFOverviewSample {   SInt16   mMinValue;  SInt16   mMaxValue; }; struct XAFOverview {   UInt32 mEditCount;  UInt32 mNumFramesPerOVWSample;   XAFOverviewSamplemData[kVariableLengthArray]; }; typedef struct XAFOverview XAFOverview;where

mNumFramesPerOVWSample describes the number of frames of audio data thatare represented by a single OVW sample;

mData—data in each byte of the Overview Sample is a big-endian signed 16bit integer. There are two data points per sample, a minimum and maximumamplitude.

An overview chunk's header includes a UInt32 sized field mEditCount.When an overview chunk is created, the mEditCount field (e.g., thedependency indicator 124 of FIG. 1) should be set to the current valueof the edit count field of the data chunk used to create the overview.Consequently, a program can then validate whether an overview is stillvalid by comparing the value of an overview's edit count with thecurrent value of the data chunk's edit count. If they don't match, thenthe overview should be considered to be invalid, and regenerated. Therecan be multiple overview data chunks that may include the samestatistics at different resolutions.

MIDI Chunk

mChunkType=‘midi’

The contents of a MIDI chunk is a standard MIDI file. A MIDI chunk canbe used to express meta-information about the audio data, for example,tempo information, key signatures, time signature, MIDI equivalence tothe audio data, etc.

Peak Chunk

mChunkType = ‘peak’ struct XAFPositionPeak {   Float32 mValue;   UInt64mFrameNumber; }.

The peak chunk gives the signed maximum absolute amplitude normalized toa floating point range in the interval [−1.0, +1.0], and gives the framein the file where that peak occurs. Integer values should be scaled bythe appropriate power of two to the interval [−1.0, +1.0). For example,the maximum positive 16 bit value is (32767.0/32768.0). The mValue fieldis conformant to the IEEE-754 specification.

The size of a peak chunk's data is:

mChunkSize=sizeof(XAFPositionPeak)*numChannelsInFile+sizeof(UInt32).

The sizeof(UInt32) here is for the mEditCount field. Thus, for a 2channel file, the peak chunk will look like this:

mChunkSize=26; //12*2+4

mEditCount=//edit count of data chunk

myPeakData.mValue[0]=// maximum dBFS value of channel 0

myPeakData.mFrameNumber[0]=// sample frame location of this maximumvalue for channel 0

myPeakData.mValue[1]=// maximum dBFS value of channel 1

myPeakData.mFrameNumber[1]=// sample frame location of this maximumvalue for channel 1.

As with the overview chunk, the edit count field of this chunk should beset to the value of the data chunk's mEditCount field when the peakchunk is created. There should be only one peak chunk in the file. Ifthe edit count of the peak chunk does not match the edit count of theaudio data chunk, then the peak chunk's data should be consideredinvalid, and thus regenerated. The flags and version fields should beset to zero in this specification.

UMID Chunk

mChunkType=‘umid’

The Unique Material Identifier is defined by the SMPTE organization(SMPTE 330M-2000) and is used within the broadcast and other industriesto uniquely identify material contained within a file or collection offiles. The Size of a UMID chunk is 64 bytes. There can be only one UMIDchunk within a file. If a 32 byte basic UMID is used, the following 32bytes should be set to zero. It is expected that the guidelinespublished by the European Broadcast Union (EBU) for the use of UMID'swith audio content are adhered to in XAF file usage.

Information Chunk

mChunkType = ‘info’ struct XAFStringsChunk {   UInt32   mNumEntries; //struct { //  UInt8 mKey[kVariableLengthArray];  // null terminated UTF8string //  UInt8 mValue[kVariableLengthArray]; // null terminated UTF8string // } mStrings[kVariableLengthArray];  // variable length };

The information chunk can contain any number of string key-value pairs,where the key-value pairs themselves are fairly arbitrary. ThemChunkSize size of an information chunk is the number of bytes occupiedby the key-value strings and the 4 bytes for the mNumEntries field.

Information in the information chunk may also occur in other chunkswithin an XAF file. In such a scenario, the other chunks take precedenceover the information chunk. For example, a file may contain both anentry for key signature and tempo in the information chunk, but alsocontain a MIDI chunk with both key and tempo MIDI events. If there is aconflict, then the information contained in the MIDI chunk takesprecedence over the information in the information chunk.

The following is an exemplary, non-exhaustive and non-limiting list ofvalues for information keys.

base note is the base note (if applicable) of the audio data. Thisstring contains a MIDI note number and can be fractional to handle “outof tune” samples (e.g. “60.12” is twelve cents above middle C). The ‘.’character must be used as the separator between note number and itsfractional part.

-   -   tempo is the base tempo of the audio data in beats per minute.    -   key signature—e.g., “C”, “Cm”, “C#”, “Cb”. The note is        capitalized with values from A to G, ‘m’ is for minor, ‘b’ is        for flat, ‘#’ is for sharp.    -   time signature—e.g., “ 4/4”, “ 6/8”.    -   artist identifies the artist/creator of the audio.    -   album identifies the title of the album/musical collection, if        any.    -   track number is the number of the track of the album/musical        collection.    -   year is the year that the album/musical collection was made.    -   composer identifies the composer of the audio, if any.    -   lyricist identifies the lyricist, if any.    -   genre identifies the genre of audio, if applicable.    -   title is the nominal title or name of the contained        song/loop/sample etc. The title can be different from the file        name.    -   recorded time—a time of day string.    -   comments—    -   copyright is a copyright string, e.g., “2004 The CoolBandName.        All Rights Reserved”.    -   source encoder—e.g., “My AAC Encoder, v4.2”.    -   encoding application—e.g., “My App, v1.0”.    -   nominal bit rate—e.g., “128 kbits”.    -   channel layout—e.g., “stereo”, “5.1 Surround”, “10.2 Surround”,        etc.

In one embodiment, the presenting code can be implemented to prepend thestring “Copyright®” to the copyright key rather than including this inthe value of the copyright key.

Placing a ‘.’ character as the first character of a key means that thekey-value pair is generally not to be displayed. This allows differentapplications to store private information that should be preserved byother programs, without displaying data to a user that is potentiallymeaningless or confusing.

Edit Comments Chunk

mChunkType=‘edct’

This chunk is for timestamped, human readable comments that coincidewith edits to the data contained within an XAF file. The contents ofthis chunk use the same layout as the ‘info’ chunk (i.e., a UInt32mNumEntries, and a pair of key-value pairs). However, in an EditComments chunk, the keys are time of day strings, and a comment that cansummarize the edits made. Any time of day timestamps contained within anXAF file are of the format defined by the ISO-8601 specification.Details of how this format is described hereafter.

Extensibility and UUID Chunk

mChunkType=‘uuid’

This chunk type is used to provide a guaranteed unique identifier forcustomized chunks, which is based on the ISO 14496-1 specification forUUID identifiers. In one embodiment, the UUID chunk is structured asfollows.

struct XAF_UUID_ChunkHeader {   XAFChunkHeader mHeader;   UInt8  mUUID[16]; }; XAF_UUID_ChunkHeader uuidChunkHeader;uuidChunkHeader.mHeader.mChunkType = ‘uuid’;uuidChunkHeader.mHeader.mChunkFlags = 0;uuidChunkHeader.mHeader.mChunkVersion = 0;uuidChunkHeader.mHeader.mChunkSize = <size of chunk including UUID>;memcpy (uuidChunkHeader.mUUID, generatedUUID, 16).

Any data following the UUID chunk header is defined by that UUID. ThemChunkSize of the UUID chunk must include the size of the generated 16byte UUID. If the UUID chunk has dependencies on the edit count of thedata chunk, then that should be stored after the mUUID field.

For some chunks, such as Markers, Regions, and Information, it ispossible for the chunk's actual data size to be bigger than its currentvalid contents. This allows files to be created with some headroomwithin the actual data segment of a chunk to add additional content.These types of chunks contain a specifier for the number of validentries and, when parsing, this specifier should be the primary targetused to return valid data.

Miscellaneous Description

Time of Day Data Format (ISO-8601)

YYYY=four-digit year

MM=two-digit month (01=January, etc.)

DD=two-digit day of month (01 through 31)

‘T’=separator between date and time fragments

hh=two digits of hour (00 through 23) (am/pm NOT allowed)

mm=two digits of minute (00 through 59)

ss=two digits of second (00 through 59)

Some example formats are as follows:

Year:

-   -   YYYY (e.g. 1997)

Year and month:

-   -   YYYY-MM (e.g. 1997-07)

Complete date:

-   -   YYYY-MM-DD (e.g. 1997-07-16)

Complete date plus hours, minutes and seconds:

-   -   YYYY-MM-DDThh:mm:ss (e.g. 1997-07-16T19:20:30)        As per this standard's definition, fractional seconds are not        described in any XAF usage of this structure. ALL times are        described based on UTC (Coordinated Universal Time).

Channel Description Definitions

The following channel labels are used to identify channels, according toone embodiment.

  enum   {    kAudioChannelLabel_Unknown = 0xFFFFFFFF, // unknown orunspecified other use    kAudioChannelLabel_Unused  = 0, // channel ispresent, but has no intended use or destination   kAudioChannelLabel_UseCoordinates = 100, // channel is describedsolely by the mCoordinates fields.    kAudioChannelLabel_Left = 1,   kAudioChannelLabel_Right  = 2,    kAudioChannelLabel_Center  = 3,   kAudioChannelLabel_LFEScreen = 4,    kAudioChannelLabel_LeftSurround = 5, // WAVE: “Back Left”    kAudioChannelLabel_RightSurround  = 6, //WAVE: “Back Right”    kAudioChannelLabel_LeftCenter = 7,   kAudioChannelLabel_RightCenter = 8,   kAudioChannelLabel_CenterSurround  = 9, // WAVE: “Back Center” orplain “Rear Surround”    kAudioChannelLabel_LeftSurroundDirect = 10, //WAVE: “Side Left”    kAudioChannelLabel_RightSurroundDirect  = 11,  //WAVE: “Side Right”    kAudioChannelLabel_TopCenterSurround  = 12,   kAudioChannelLabel_VerticalHeightLeft = 13, // WAVE: “Top Front Left”   kAudioChannelLabel_VerticalHeightCenter = 14,  // WAVE: “Top FrontCenter”    kAudioChannelLabel_VerticalHeightRight = 15, // WAVE: “TopFront Right”    kAudioChannelLabel_TopBackLeft  = 16,   kAudioChannelLabel_TopBackCenter  = 17,   kAudioChannelLabel_TopBackRight = 18,   kAudioChannelLabel_RearSurroundLeft  = 33,   kAudioChannelLabel_RearSurroundRight   = 34,   kAudioChannelLabel_LeftWide  = 35,    kAudioChannelLabel_RightWide  =36,    kAudioChannelLabel_LFE2 = 37,    kAudioChannelLabel_LeftTotal  =38, // matrix encoded 4 channels    kAudioChannelLabel_RightTotal  = 39,// matrix encoded 4 channels    kAudioChannelLabel_HearingImpaired = 40,   kAudioChannelLabel_Narration  = 41,    kAudioChannelLabel_Mono = 42,   kAudioChannelLabel_DialogCentricMix  = 43,   kAudioChannelLabel_CenterSurroundDirect = 44, // back center, nondiffuse    // first order ambisonic channels   kAudioChannelLabel_Ambisonic_W  = 200,   kAudioChannelLabel_Ambisonic_X  = 201,   kAudioChannelLabel_Ambisonic_Y  = 202,   kAudioChannelLabel_Ambisonic_Z = 203,    // Mid/Side Recording   kAudioChannelLabel_MS_Mid = 204,    kAudioChannelLabel_MS_Side = 205,   // X-Y Recording    kAudioChannelLabel_XY_X = 206,   kAudioChannelLabel_XY_Y = 207,    // other   kAudioChannelLabel_HeadphonesLeft = 301,   kAudioChannelLabel_HeadphonesRight  = 302,   kAudioChannelLabel_ClickTrack  = 304,   kAudioChannelLabel_ForeignLanguage  = 305   };The following constants are used in the mChannelFlags field.

enum {  kAudioChannelFlags_RectangularCoordinates  = (1L<<0), kAudioChannelFlags_SphericalCoordinates  = (1L<<1), kAudioChannelFlags_Meters     = (1L<<2) };

kAudioChannelFlags_RectangularCoordinates—The channel is specified bythe cartesian coordinates of the speaker position. This flag is mutuallyexclusive with kAudioChannelFlags_SphericalCoordinates.

kAudioChannelFlags_SphericalCoordinates—The channel is specified by thespherical coordinates of the speaker position. This flag is mutuallyexclusive with kAudioChannelFlags_RectangularCoordinates.

kAudioChannelFlags_Meters—Set to indicate the units are in meters, clearto indicate the units are relative to the unit cube or unit sphere.

If the channel description provides no coordinate information, then themChannelFlags field is set to zero.

Channel Coordinates

(A) Rectangular Coordinates:

-   -   Negative is left and positive is right.    -   Negative is back and positive is front.    -   Negative is below ground level, 0 is ground level, and positive        is above ground level.

(B) Spherical Coordinates:

-   -   0 is front center, positive is right, negative is left. This is        measured in degrees.    -   +90 is zenith, 0 is horizontal, −90 is nadir. This is measured        in degrees.

Common Channel Layouts

The following is an exemplary, non-exhaustive and non-limiting list ofvalues for some common channel layouts. Abbreviations used are:

L—left

R—right

C—center

Ls—left surround

Rs—right surround

Cs—center surround

Lrs—left rear surround

Rrs—right rear surround

Lw—left wide

Rw—right wide

Lsd—left surround direct

Rsd—right surround direct

Lc—left center

Rc—right center

Ts—top surround

Vhl—vertical height left

Vhc—vertical height center

Vhr—vertical height right

Lt—left matrix total. for matrix encoded stereo.

Rt—right matrix total. for matrix encoded stereo.

In the following descriptions, ordering of the channels for a givenlayout is not implied. For example, while 5.1 is described as L, R, Ls,Rs, C, LFE, a file can contain these channels in any order. The order ofthe channel descriptions in the Channel Descriptions chunk of a filedetermines the order in which the channels contained in that particularfile are presented.

2 Channel Files

Stereo—a standard stereo stream (L R)—implied playback;

StereoHeadphones—a standard stereo stream (L R)—implied headphoneplayback;

MatrixStereo—a matrix encoded stereo stream (Lt, Rt);

MidSide—mid/side recording;

XY—coincident mic pair (often 2 figure 8's);

Binaural—binaural stereo (left, right).

3 Channel Files

MPEG 3.0—L, R, C;

ITU 2.1—L, R, LFE.

4 Channel Files

Quadraphonic—front left, front right, back left, back right;

Ambisonic_B_Format—W, X, Y, Z;

MPEG4.0-L, R, C, Cs.

5 Channel Files

Pentagonal—left, right, rear left, rear right, center;

MPEG 5.0—L, R, Ls, Rs, C.

6 Channel Files

Hexagonal—left, right, rear left, rear right, center, rear;

MPEG 5.1—L, R, Ls, Rs, C, LFE;

MPEG 6.0—L, R, Ls, Rs, C, Cs.

7 Channel Files

MPEG 6.1—L, R, Ls, Rs, C, Cs, LFE;

MPEG 7.0—L, R, Ls, Rs, C, Lrs, Rrs;

MPEG 7.0 (B)—L, R, Ls, Rs, C, Lc, Rc.

8 Channel Files

Octagonal—front left, front right, rear left, rear right, front center,rear center, side left, side right;

Cube—left, right, rear left, rear right, top left, top right, top rearleft, top rear right;

MPEG 7.1—L, R, Ls, Rs, C, Lrs, Rrs, LFE;

MPEG 7.0 (B)—L, R, Ls, Rs, C, Lc, Rc, LFE;

SMPTE_DTV—L, R, C, LFE, Ls, Rs, Lt, Rt (MPEG 5.1 plus a matrix encodedstereo mix).

16 Channel Files

TMH 10.2 Standard—L, R, C, Vhc, Lsd, Rsd, Ls, Rs, Vhl, Vhr, Lw, Rw, Csd,Cs, LFE1, LFE2

21 Channel Files

TMH 10.2 Full—(TMH 10.2 Standard plus) Lc, Rc, HI, VI, Haptic.

Hardware Overview

FIG. 4 is a block diagram that illustrates a computer system 400 uponwhich an embodiment of the invention may be implemented. A computersystem as illustrated in FIG. 4 is but one possible system on whichembodiments of the invention may be implemented and practiced. Forexample, embodiments of the invention may be implemented on any suitablyconfigured device, such as a handheld or otherwise portable device, adesktop device, a set-top device, a networked device, and the like,configured for recording, processing or playing audio files. Hence, allof the components that are illustrated and described in reference toFIG. 4 are not necessary for implementing embodiments of the invention.

Computer system 400 includes a bus 402 or other communication mechanismfor communicating information, and a processor 404 coupled with bus 402for processing information. Computer system 400 also includes a mainmemory 406, such as a random access memory (RAM) or other dynamicstorage device, coupled to bus 402 for storing information andinstructions to be executed by processor 404. Main memory 406 also maybe used for storing temporary variables or other intermediateinformation during execution of instructions to be executed by processor404. Computer system 400 further includes a read only memory (ROM) 408or other static storage device coupled to bus 402 for storing staticinformation and instructions for processor 404. A storage device 410,such as a magnetic disk, optical disk, or magneto-optical disk, isprovided and coupled to bus 402 for storing information andinstructions.

Computer system 400 may be coupled via bus 402 to a display 412, such asa cathode ray tube (CRT) or a liquid crystal display (LCD), fordisplaying information to a system user. In the context of computersystem 400 as an audio recording and playback system, computer system400 may be coupled to an audio output device, such as speakers or aheadphone jack, for playing audio to a system user. An input device 414,including alphanumeric and other keys, is coupled to bus 402 forcommunicating information and command selections to processor 404.Another type of user input device is cursor control 416, such as amouse, a trackball, a stylus or cursor direction keys for communicatingdirection information and command selections to processor 404 and forcontrolling cursor movement on display 412. This input device typicallyhas two degrees of freedom in two axes, a first axis (e.g., x) and asecond axis (e.g., y), that allows the device to specify positions in aplane.

The invention is related to the use of computer system 400 forimplementing the techniques described herein. According to oneembodiment of the invention, those techniques are performed by computersystem 400 in response to processor 404 executing one or more sequencesof one or more instructions contained in main memory 406. Suchinstructions may be read into main memory 406 from anothercomputer-readable medium, such as storage device 410. Execution of thesequences of instructions contained in main memory 406 causes processor404 to perform the process steps described herein. In alternativeembodiments, hard-wired circuitry may be used in place of or incombination with software instructions to implement the invention. Thus,embodiments of the invention are not limited to any specific combinationof hardware circuitry and software.

The term “computer-readable medium” as used herein refers to any mediumthat participates in providing instructions to processor 404 forexecution. Such a medium may take many forms, including but not limitedto, non-volatile media, volatile media, and transmission media.Non-volatile media includes, for example, optical, magnetic, ormagneto-optical disks, such as storage device 410. Volatile mediaincludes dynamic memory, such as main memory 406. Transmission mediaincludes coaxial cables, copper wire and fiber optics, including thewires that comprise bus 402. Transmission media can also take the formof acoustic or light waves, such as those generated during radio-waveand infra-red data communications.

Common forms of computer-readable media include, for example, a floppydisk, a flexible disk, hard disk, magnetic tape, or any other magneticmedium, a CD-ROM, any other optical medium, punchcards, papertape, anyother physical medium with patterns of holes, a RAM, a PROM, and EPROM,a FLASH-EPROM, any other memory chip or cartridge, a carrier wave asdescribed hereinafter, or any other medium from which a computer canread.

Various forms of computer readable media may be involved in carrying oneor more sequences of one or more instructions to processor 404 forexecution. For example, the instructions may initially be carried on amagnetic disk of a remote computer. The remote computer can load theinstructions into its dynamic memory and send the instructions over atelephone line using a modem. A modem local to computer system 400 canreceive the data on the telephone line and use an infra-red transmitterto convert the data to an infra-red signal. An infra-red detector canreceive the data carried in the infra-red signal and appropriatecircuitry can place the data on bus 402. Bus 402 carries the data tomain memory 406, from which processor 404 retrieves and executes theinstructions. The instructions received by main memory 406 mayoptionally be stored on storage device 410 either before or afterexecution by processor 404.

Computer system 400 also includes a communication interface 418 coupledto bus 402. Communication interface 418 provides a two-way datacommunication coupling to a network link 420 that is connected to alocal network 422. For example, communication interface 418 may be anintegrated services digital network (ISDN) card or a modem to provide adata communication connection to a corresponding type of telephone line.As another example, communication interface 418 may be a local areanetwork (LAN) card to provide a data communication connection to acompatible LAN. Wireless links may also be implemented. In any suchimplementation, communication interface 418 sends and receiveselectrical, electromagnetic or optical signals that carry digital datastreams representing various types of information.

Network link 420 typically provides data communication through one ormore networks to other data devices. For example, network link 420 mayprovide a connection through local network 422 to a host computer 424 orto data equipment operated by an Internet Service Provider (ISP) 426.ISP 426 in turn provides data communication services through the worldwide packet data communication network now commonly referred to as the“Internet” 428. Local network 422 and Internet 428 both use electrical,electromagnetic or optical signals that carry digital data streams. Thesignals through the various networks and the signals on network link 420and through communication interface 418, which carry the digital data toand from computer system 400, are exemplary forms of carrier wavestransporting the information.

Computer system 400 can send messages and receive data, includingprogram code, through the network(s), network link 420 and communicationinterface 418. In the Internet example, a server 430 might transmit arequested code for an application program through Internet 428, ISP 426,local network 422 and communication interface 418.

The received code may be executed by processor 404 as it is received,and/or stored in storage device 410, or other non-volatile storage forlater execution. In this manner, computer system 400 may obtainapplication code in the form of a carrier wave.

Extensions and Alternatives

Alternative embodiments of the invention are described throughout theforegoing description, and in locations that best facilitateunderstanding the context of the embodiments. Furthermore, the inventionhas been described with reference to specific embodiments thereof. Itwill, however, be evident that various modifications and changes may bemade thereto without departing from the broader spirit and scope of theinvention. Therefore, the specification and drawings are, accordingly,to be regarded in an illustrative rather than a restrictive sense.

In addition, in this description certain process steps are set forth ina particular order, and alphabetic and alphanumeric labels may be usedto identify certain steps. Unless specifically stated in thedescription, embodiments of the invention are not necessarily limited toany particular order of carrying out such steps. In particular, thelabels are used merely for convenient identification of steps, and arenot intended to specify or require a particular order of carrying outsuch steps.

1. A method for handling audio information, comprising: storing, as partof a single audio file, a flag that is able to assume at least (1) afirst state that indicates that a last chunk in said single audio fileis an audio data chunk that contains incomplete audio data, and (2) asecond state that indicates that said audio data chunk contains completeaudio data; performing a plurality of storage operations to store audiodata in said audio data chunk; wherein after completion of each theplurality of storage operations, the size of said audio data chunk isequal to a difference between a file size of said single audio file anda starting position of said last chunk in said single audio file; andwhile performing said plurality of storage operations, maintaining saidflag in said first state; wherein the method is performed by one or morecomputing devices.
 2. The method of claim 1, further comprising: settingsaid flag to said second state in response to successfully completingsaid plurality of storage operations.
 3. The method of claim 2: whereinsaid flag is a parameter that indicates the size of the audio datachunk; wherein said parameter is initially set to a value that does notcorrespond to a valid audio data chunk size; and wherein setting saidflag to said second state in response to successfully completing saidplurality of storage operations includes setting said parameter to avalue that reflects an actual size of said audio data chunk.
 4. Themethod of claim 1, further comprising: setting said flag to said secondstate in response to adding to said single audio file a chunk thatfollows said audio data chunk within said single audio file.
 5. Themethod of claim 1, further comprising: setting said flag to said secondstate in response to adding audio data to said audio data chunk.
 6. Themethod of claim 1: wherein the flag is a parameter that indicates thesize of said audio data chunk; and wherein the parameter is initiallyset to a value that does not correspond to a valid audio data chunksize.
 7. The method of claim 1, further comprising: storing, as part ofsaid single audio file, (a) metadata information that includes one ormore metadata values; (b) state information for said audio data thatidentifies a current version of said audio data; and (c) one or moredependency indicators, wherein each of the one or more dependencyindicators is associated with one or more of the one or more metadatavalues, wherein each dependency indicator identifies a version of theaudio data on which the one or more metadata values that are associatedwith said each dependency indicator are dependent.
 8. Acomputer-readable storage medium storing instructions which, whenexecuted by one or more computing devices, cause the one or morecomputing devices to perform: storing, as part of a single audio file, aflag that is able to assume at least (1) a first state that indicatesthat a last chunk in said single audio file is an audio data chunk thatcontains incomplete audio data, and (2) a second state that indicatesthat said audio data chunk contains complete audio data; performing aplurality of storage operations to store audio data in said audio datachunk; wherein after completion of each the plurality of storageoperations, the size of said audio data chunk is equal to a differencebetween a file size of said single audio file and a starting position ofsaid last chunk in said single audio file; and while performing saidplurality of storage operations, maintaining said flag in said firststate.
 9. The computer-readable storage medium of claim 8, wherein saidinstructions, when executed by the one or more computing devices, causethe one or more computing devices to further perform: setting said flagto said second state in response to successfully completing saidplurality of storage operations.
 10. The computer-readable storagemedium of claim 9: wherein said flag is a parameter that indicates thesize of the audio data chunk; wherein said parameter is initially set toa value that does not correspond to a valid audio data chunk size; andwherein setting said flag to said second state in response tosuccessfully completing said plurality of storage operations includessetting said parameter to a value that reflects an actual size of saidaudio data chunk.
 11. The computer-readable storage medium of claim 8,wherein said instructions, when executed by the one or more computingdevices, cause the one or more computing devices to further perform:setting said flag to said second state in response to adding to saidsingle audio file a chunk that follows said audio data chunk within saidsingle audio file.
 12. The computer-readable storage medium of claim 8,wherein said instructions, when executed by the one or more computingdevices, cause the one or more computing devices to further perform:setting said flag to said second state in response to adding audio datato said audio data chunk.
 13. The computer-readable storage medium ofclaim 8: wherein the flag is a parameter that indicates the size of saidaudio data chunk; and wherein the parameter is initially set to a valuethat does not correspond to a valid audio data chunk size.
 14. Thecomputer-readable storage medium of claim 8, wherein said instructions,when executed by the one or more computing devices, cause the one ormore computing devices to further perform: storing, as part of saidsingle audio file, (a) metadata information that includes one or moremetadata values; (b) state information for said audio data thatidentifies a current version of said audio data; and (c) one or moredependency indicators, wherein each of the one or more dependencyindicators is associated with one or more of the one or more metadatavalues, wherein each dependency indicator identifies a version of theaudio data on which the one or more metadata values that are associatedwith said each dependency indicator are dependent.
 15. A computer systemcomprising: one or more processors; and logic encoded in one or morecomputer-readable storage media wherein execution by the one or moreprocessors causes: storing, as part of a single audio file, a flag thatis able to assume at least (1) a first state that indicates that a lastchunk in said single audio file is an audio data chunk that containsincomplete audio data, and (2) a second state that indicates that saidaudio data chunk contains complete audio data; performing a plurality ofstorage operations to store audio data in said audio data chunk; whereinafter completion of each the plurality of storage operations, the sizeof said audio data chunk is equal to a difference between a file size ofsaid single audio file and a starting position of said last chunk insaid single audio file; and while performing said plurality of storageoperations, maintaining said flag in said first state; wherein themethod is performed by one or more computing devices.
 16. The computersystem of claim 15, wherein said logic, when executed by the one or moreprocessors, further causes: setting said flag to said second state inresponse to successfully completing said plurality of storageoperations.
 17. The computer system of claim 16: wherein said flag is aparameter that indicates the size of the audio data chunk; wherein saidparameter is initially set to a value that does not correspond to avalid audio data chunk size; and wherein setting said flag to saidsecond state in response to successfully completing said plurality ofstorage operations includes setting said parameter to a value thatreflects an actual size of said audio data chunk.
 18. The computersystem of claim 15, wherein said logic, when executed by the one or moreprocessors, further causes: setting said flag to said second state inresponse to adding to said single audio file a chunk that follows saidaudio data chunk within said single audio file.
 19. The computer systemof claim 15, wherein said logic, when executed by the one or moreprocessors, further causes: setting said flag to said second state inresponse to adding audio data to said audio data chunk.
 20. The computersystem of claim 15: wherein the flag is a parameter that indicates thesize of said audio data chunk; and wherein the parameter is initiallyset to a value that does not correspond to a valid audio data chunksize.
 21. The computer system of claim 15, wherein said logic, whenexecuted by the one or more processors, further causes: storing, as partof said single audio file, (a) metadata information that includes one ormore metadata values; (b) state information for said audio data thatidentifies a current version of said audio data; and (c) one or moredependency indicators, wherein each of the one or more dependencyindicators is associated with one or more of the one or more metadatavalues, wherein each dependency indicator identifies a version of theaudio data on which the one or more metadata values that are associatedwith said each dependency indicator are dependent.
 22. A method forhandling audio information, comprising: storing, as part of a singleaudio file, (a) audio data; (b) metadata information that includes oneor more metadata values; (c) state information for said audio data thatidentifies a current version of said audio data; and (d) one or moredependency indicators, wherein each of the one or more dependencyindicators is associated with one or more of the one or more metadatavalues, wherein each dependency indicator identifies a version of theaudio data on which the one or more metadata values that are associatedwith said each dependency indicator are dependent; wherein the method isperformed by one or more computing devices.
 23. The method of claim 22,further comprising: changing said state information in response tochanges made to said audio data.
 24. The method of claim 22, furthercomprising: initially setting the one or more dependency indicators to avalue that corresponds to said state information for said audio data.25. The method of claim 22, wherein said one or more metadata valuesinclude a plurality of metadata values, each of which has a distinctdependency indicator.
 26. The method of claim 22, wherein a dependencyindicator associated with a particular metadata value of said one ormore metadata values corresponds to an outdated state of said audiodata, the method further comprising: setting said particular metadatavalue to a new value that is derived from a current state of said audiodata; and in response to setting said particular metadata to said newvalue, changing said dependency indicator for said particular metadatavalue to a value that corresponds to said current state information forsaid audio data.
 27. The method of claim 22, wherein: said single audiofile stores said metadata information in one or more metadata chunks;said single audio file stores said audio data in an audio data chunk;and each of said one or more dependency indicators corresponds to ametadata chunk of said one or more metadata chunks, and indicates whatversion of said data chunk was used to derive metadata values withinsaid metadata chunk.
 28. The method of claim 22, wherein storing one ormore dependency indicators associated with said one or more metadatavalues includes storing a dependency indicator associated with ametadata value that represents a maximum amplitude within said audiodata.
 29. The method of claim 22, wherein storing one or more dependencyindicators associated with said one or more metadata values includesstoring a dependency indicator associated with a metadata value thatrepresents a minimum amplitude within said audio data.
 30. The method ofclaim 22, wherein storing one or more dependency indicators associatedwith said one or more metadata values includes storing a dependencyindicator associated with a metadata value that identifies a frame, insaid audio data, in which a maximum amplitude occurs within said audiodata.
 31. The method of claim 22, further comprising: storing, as partof said single audio file, a flag that is able to assume at least (1) afirst state that indicates that a last chunk in said single audio fileis an audio data chunk that contains incomplete audio data, and (2) asecond state that indicates that said audio data chunk contains completeaudio data; performing a plurality of storage operations to store audiodata in said audio data chunk; wherein after completion of each theplurality of storage operations, the size of said audio data chunk isequal to a difference between a file size of said single audio file anda starting position of said last chunk in said single audio file; andwhile performing said plurality of storage operations, maintaining saidflag in said first state.
 32. A computer-readable storage medium storinginstructions which, when executed by one or more computing devices,cause the one or more computing devices to perform: storing, as part ofa single audio file, (a) audio data; (b) metadata information thatincludes one or more metadata values; (c) state information for saidaudio data that identifies a current version of said audio data; and (d)one or more dependency indicators, wherein each of the one or moredependency indicators is associated with one or more of the one or moremetadata values, wherein each dependency indicator identifies a versionof the audio data on which the one or more metadata values that areassociated with said each dependency indicator are dependent.
 33. Thecomputer-readable storage medium of claim 32, wherein said instructions,when executed by the one or more computing devices, cause the one ormore computing devices to further perform: changing said stateinformation in response to changes made to said audio data.
 34. Thecomputer-readable storage medium of claim 32, wherein said instructions,when executed by the one or more computing devices, cause the one ormore computing devices to further perform: initially setting the one ormore dependency indicators to a value that corresponds to said stateinformation for said audio data.
 35. The computer-readable storagemedium of claim 32, wherein said one or more metadata values include aplurality of metadata values, each of which has a distinct dependencyindicator.
 36. The computer-readable storage medium of claim 32, whereina dependency indicator associated with a particular metadata value ofsaid one or more metadata values corresponds to an outdated state ofsaid audio data, and said instructions, when executed by the one or morecomputing devices, cause the one or more computing devices to furtherperform: setting said particular metadata value to a new value that isderived from a current state of said audio data; and in response tosetting said particular metadata to said new value, changing saiddependency indicator for said particular metadata value to a value thatcorresponds to said current state information for said audio data. 37.The computer-readable storage medium of claim 32, wherein: said singleaudio file stores said metadata information in one or more metadatachunks; said single audio file stores said audio data in an audio datachunk; and each of said one or more dependency indicators corresponds toa metadata chunk of said one or more metadata chunks, and indicates whatversion of said data chunk was used to derive metadata values withinsaid metadata chunk.
 38. The computer-readable storage medium of claim32, wherein storing one or more dependency indicators associated withsaid one or more metadata values includes storing a dependency indicatorassociated with a metadata value that represents a maximum amplitudewithin said audio data.
 39. The computer-readable storage medium ofclaim 32, wherein storing one or more dependency indicators associatedwith said one or more metadata values includes storing a dependencyindicator associated with a metadata value that represents a minimumamplitude within said audio data.
 40. The computer-readable storagemedium of claim 32, wherein storing one or more dependency indicatorsassociated with said one or more metadata values includes storing adependency indicator associated with a metadata value that identifies aframe, in said audio data, in which a maximum amplitude occurs withinsaid audio data.
 41. The computer-readable storage medium of claim 32,wherein said instructions, when executed by the one or more computingdevices, cause the one or more computing devices to perform: storing, aspart of said single audio file, a flag that is able to assume at least(1) a first state that indicates that a last chunk in said single audiofile is an audio data chunk that contains incomplete audio data, and (2)a second state that indicates that said audio data chunk containscomplete audio data; performing a plurality of storage operations tostore audio data in said audio data chunk; wherein after completion ofeach the plurality of storage operations, the size of said audio datachunk is equal to a difference between a file size of said single audiofile and a starting position of said last chunk in said single audiofile; and while performing said plurality of storage operations,maintaining said flag in said first state.
 42. A computer systemcomprising: one or more processors; and logic encoded in one or morecomputing readable storage media wherein execution by the one or moreprocessors causes: storing, as part of a single audio file, (a) audiodata; (b) metadata information that includes one or more metadatavalues; (c) state information for said audio data that identifies acurrent version of said audio data; and (d) one or more dependencyindicators, wherein each of the one or more dependency indicators isassociated with one or more of the one or more metadata values, whereineach dependency indicator identifies a version of the audio data onwhich the one or more metadata values that are associated with said eachdependency indicator are dependent.
 43. The computer system of claim 42,wherein said logic, when executed by the one or more processors, furthercauses: changing said state information in response to changes made tosaid audio data.
 44. The computer system of claim 42, wherein saidlogic, when executed by the one or more processors, further causes:initially setting the one or more dependency indicators to a value thatcorresponds to said state information for said audio data.
 45. Thecomputer system of claim 42, wherein said one or more metadata valuesinclude a plurality of metadata values, each of which has a distinctdependency indicator.
 46. The computer system of claim 42, wherein adependency indicator associated with a particular metadata value of saidone or more metadata values corresponds to an outdated state of saidaudio data; and said logic, when executed by the one or more processors,further causes: setting said particular metadata value to a new valuethat is derived from a current state of said audio data; and in responseto setting said particular metadata to said new value, changing saiddependency indicator for said particular metadata value to a value thatcorresponds to said current state information for said audio data. 47.The computer system of claim 42, wherein: said single audio file storessaid metadata information in one or more metadata chunks; said singleaudio file stores said audio data in an audio data chunk; and each ofsaid one or more dependency indicators corresponds to a metadata chunkof said one or more metadata chunks, and indicates what version of saiddata chunk was used to derive metadata values within said metadatachunk.
 48. The computer system of claim 42, wherein storing one or moredependency indicators associated with said one or more metadata valuesincludes storing a dependency indicator associated with a metadata valuethat represents a maximum amplitude within said audio data.
 49. Thecomputer system of claim 42, wherein storing one or more dependencyindicators associated with said one or more metadata values includesstoring a dependency indicator associated with a metadata value thatrepresents a minimum amplitude within said audio data.
 50. The computersystem of claim 42, wherein storing one or more dependency indicatorsassociated with said one or more metadata values includes storing adependency indicator associated with a metadata value that identifies aframe, in said audio data, in which a maximum amplitude occurs withinsaid audio data.
 51. The computer system of claim 42, wherein saidlogic, when executed by the one or more processors, further causes:storing, as part of said single audio file, a flag that is able toassume at least (1) a first state that indicates that a last chunk insaid single audio file is an audio data chunk that contains incompleteaudio data, and (2) a second state that indicates that said audio datachunk contains complete audio data; performing a plurality of storageoperations to store audio data in said audio data chunk; wherein aftercompletion of each the plurality of storage operations, the size of saidaudio data chunk is equal to a difference between a file size of saidsingle audio file and a starting position of said last chunk in saidsingle audio file; and while performing said plurality of storageoperations, maintaining said flag in said first state.
 52. A method forstoring audio information, the method comprising: storing, as part of asingle audio file, (a) a flag that is able to assume at least (1) afirst state that indicates that a last chunk in said single audio fileis an audio data chunk that contains incomplete audio data, and (2) asecond state that indicates that said audio data chunk contains completeaudio data; (b) audio data; (c) metadata information that includes oneor more metadata values; (d) state information for said audio data thatidentifies a current version of said audio data; and (e) one or moredependency indicators, wherein each of the one or more dependencyindicators is associated with one or more of the one or more metadatavalues, wherein each dependency indicator identifies a version of theaudio data on which the one or more metadata values that are associatedwith said each dependency indicator are dependent; performing aplurality of storage operations to store audio data in said audio datachunk; wherein after completion of each the plurality of storageoperations, the size of said audio data chunk is equal to a differencebetween a file size of said single audio file and a starting position ofsaid last chunk in said single audio file; and while performing saidplurality of storage operations, maintaining said flag in said firststate; wherein the method is performed by one or more computing devices.